import java.util.List;
import java.util.Scanner;

public class Test {
    
    //链表中环的入口结点
    //牛客：NC3
    public class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }

    public static ListNode EntryNodeOfLoop2(ListNode pHead) {
        //使用快慢指针的做法
        //简化代码
        if (pHead == null || pHead.next == null) {
            return null;
        }
        ListNode fast = pHead;
        ListNode slow = pHead;

        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;

            if(fast == slow) {
                fast = pHead;
                while (fast != slow) {
                    fast = fast.next;
                    slow = slow.next;
                }
                return slow;
            }
        }
        return null;

    }

    private static ListNode hasCycle (ListNode pHead) {
        //判断是否存在环，如果存在返回相遇的节点
        if (pHead == null) {
            return null;
        }
        //使用 快慢指针
        ListNode fast = pHead;
        ListNode slow = pHead;
        //判断是否有环，有环的话，返回 fast 和 slow 相遇的节点
        while(fast != null && fast.next != null) {//这里的判断顺序不能更改
            fast = fast.next.next;
            slow = slow.next;

            if (fast == slow) {
                //证明有环，并且相遇，返回
                return slow;
            }
        }

        //这时没有环
        return null;
    }
    public static ListNode EntryNodeOfLoop(ListNode pHead) {
        //使用快慢指针的做法

        //这里返回的是 fast 和 slow 在环中相遇的节点
        ListNode slow = hasCycle(pHead);
        //这里返回的可能是空，所以我们要判断一下
        if (slow == null) {
            return null;
        }
        //把 fast 再次返回到 头结点的位置
        ListNode fast = pHead;

        //这时候，我们把fast 和 slow 一起一步步的走，在相遇的时候呢，就是环的入口
        while(fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }

        //这个时候，它们相遇了，返回其中一个即可
        return slow;
    }



    public static void main4(String[] args) {
        //牛牛的快递
        //牛客：BC64
        Scanner in = new Scanner(System.in);
        float x = in.nextFloat();
        char s = in.next().charAt(0);

        int ret = 0;
        if(x <= 1) {
            ret = 20;
        }else {
            ret = 20 + (int)(x - 0.1);
        }

        if(s == 'y') {
            System.out.println(ret + 5);
        }else {
            System.out.println(ret);
        }
    }

    public static void main3(String[] args) {
        //小乐乐该数字
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int num = in.nextInt();
        //使用 StringBuilder 来拼接结果
        StringBuilder str = new StringBuilder();
        while(num > 0) {
            //我们是从后往前判断的
            //每次把 num % 10 % 2 得到 0 或者 1
            str.append(num % 10 % 2);
            //之后进行 /10 操作
            num /= 10;
        }
        //把得到的 StringBuilder 进行翻转，再转为String类，之后转换为 int类
        int ret = Integer.parseInt(str.reverse().toString());
        System.out.println(ret);
    }

    private static void exchange (long n,long m) {
        long temp = n;
        n = m;
        m = temp;
    }
    public static void main2(String[] args) {
        //小乐乐与欧几里得
        Scanner in = new Scanner(System.in);
        //辗转相除法:
        //也称为欧几里得算法，通过连续除法，将较大数除以较小数，
        //再用出现的余数去除上一个除数，直到余数为0，
        //最后的除数即为最大公约数。

        //利用最大公约数
        //已知两数的最大公约数，可以使用公式：
        //最小公倍数 = 两数乘积 ÷ 最大公约数。

        long n = (long) in.nextInt();
        long m = (long) in.nextInt();
        //保持 n 为最大的数
        long minB = n * m;
        if(n < m) {
            exchange(n,m);
        }

        long r = n % m;
        while(r != 0) {
            n = m;
            m = r;
            r = n % m;
        }
        long maxY = m;
        minB /= maxY;

        System.out.println(maxY + minB);
    }

    public static void main1(String[] args) {
        //判断是不是字母
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String s = in.next();
            //第二种：使用正则表达式
            if(s.matches("[a-zA-Z]")) {
                System.out.println(s + " is an alphabet.");
            }else  {
                System.out.println(s + " is not an alphabet.");
            }
            //第一种:
            // char ch = s.charAt(0);
            // boolean bool = Character.isLetter(ch);
            // if(bool) {
            //     System.out.println(ch + " is an alphabet.");
            // }else {
            //     System.out.println(ch + " is not an alphabet.");
            // }
        }
    }
}
